//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.erp.helloworld.dao.idl.GetHelloWorldByIdReq.java


#ifndef ERP_HELLOWORLD_DDO_CHELLOWORLDFILTERDDO_BY_AUTOGEN_V5_H
#define ERP_HELLOWORLD_DDO_CHELLOWORLDFILTERDDO_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <set>
#include <map>
#include <string>
#include <sstream>
#include <iostream>


namespace erp
{
namespace helloworld
{
namespace ddo
{


class CHelloWorldFilterDdo : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 *  版本号   
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * 版本 >= 0
		 */
		uint8_t cVersion_u;

		/**
		 *  页码，从0开始 
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPage;

		/**
		 * 版本 >= 0
		 */
		uint8_t cPage_u;

		/**
		 *  页面大小 
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPageSize;

		/**
		 * 版本 >= 0
		 */
		uint8_t cPageSize_u;

		/**
		 *  排序方式 
		 *
		 * 版本 >= 0
		 */
		uint16_t wOrderType;

		/**
		 * 版本 >= 0
		 */
		uint8_t cOrderType_u;

		/**
		 * Id列表，若填写则其他过滤条件无效
		 *
		 * 版本 >= 0
		 */
		std::set<uint32_t>  setIdList;

		/**
		 * 版本 >= 0
		 */
		uint8_t cIdList_u;

		/**
		 *  HelloWorld 名称 
		 *
		 * 版本 >= 0
		 */
		std::string strHelloWorldName;

		/**
		 * 版本 >= 0
		 */
		uint8_t cHelloWorldName_u;

		/**
		 *  添加时间，上限
		 *
		 * 版本 >= 0
		 */
		uint32_t dwCreateTimeBegin;

		/**
		 * 版本 >= 0
		 */
		uint8_t cCreateTimeBegin_u;

		/**
		 *  添加时间，下限
		 *
		 * 版本 >= 0
		 */
		uint32_t dwCreateTimeEnd;

		/**
		 * 版本 >= 0
		 */
		uint8_t cCreateTimeEnd_u;

		/**
		 *  扩展
		 *
		 * 版本 >= 0
		 */
		std::map<std::string,std::string>  mapExtern;

		/**
		 * 版本 >= 0
		 */
		uint8_t cExtern_u;




	public:
		CHelloWorldFilterDdo():
		dwVersion(0),
		cVersion_u(0),
		dwPage(0),
		cPage_u(0),
		dwPageSize(0),
		cPageSize_u(0),
		wOrderType(0),
		cOrderType_u(0),
		cIdList_u(0),
		cHelloWorldName_u(0),
		dwCreateTimeBegin(0),
		cCreateTimeBegin_u(0),
		dwCreateTimeEnd(0),
		cCreateTimeEnd_u(0),
		cExtern_u(0) {}
				CHelloWorldFilterDdo& operator = (const CHelloWorldFilterDdo& obj){

			this->dwVersion = obj.dwVersion;
			this->cVersion_u = obj.cVersion_u;
			this->dwPage = obj.dwPage;
			this->cPage_u = obj.cPage_u;
			this->dwPageSize = obj.dwPageSize;
			this->cPageSize_u = obj.cPageSize_u;
			this->wOrderType = obj.wOrderType;
			this->cOrderType_u = obj.cOrderType_u;
			this->setIdList = obj.setIdList;
			this->cIdList_u = obj.cIdList_u;
			this->strHelloWorldName = obj.strHelloWorldName;
			this->cHelloWorldName_u = obj.cHelloWorldName_u;
			this->dwCreateTimeBegin = obj.dwCreateTimeBegin;
			this->cCreateTimeBegin_u = obj.cCreateTimeBegin_u;
			this->dwCreateTimeEnd = obj.dwCreateTimeEnd;
			this->cCreateTimeEnd_u = obj.cCreateTimeEnd_u;
			this->mapExtern = obj.mapExtern;
			this->cExtern_u = obj.cExtern_u;
			return *this;
		}

	public:


		/**
		 * 是否设置 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置 版本号   
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取 版本号   
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cVersion_u
		 *  
		 * 
		 */
		 void  SetVersion_u( const uint8_t& sVal){
				cVersion_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cVersion_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetVersion_u() const {
				return cVersion_u;
		}


		/**
		 * 是否设置 页码，从0开始 了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 bool  IsPageSet() const{
				 return  cPage_u != 0;
		}


		/**
		 * 获取uflag 页码，从0开始 了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 const uint8_t   GetPageUFlag() const{
				 return  cPage_u;
		}


		/**
		 * 设置 页码，从0开始 
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 void  SetPage( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPage = sVal;
				cPage_u = cUFlag;
		}


		/**
		 * 获取 页码，从0开始 
		 * 
		 * @return dwPage value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPage() const {
				return dwPage;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cPage_u
		 *  
		 * 
		 */
		 void  SetPage_u( const uint8_t& sVal){
				cPage_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cPage_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetPage_u() const {
				return cPage_u;
		}


		/**
		 * 是否设置 页面大小 了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 bool  IsPageSizeSet() const{
				 return  cPageSize_u != 0;
		}


		/**
		 * 获取uflag 页面大小 了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 const uint8_t   GetPageSizeUFlag() const{
				 return  cPageSize_u;
		}


		/**
		 * 设置 页面大小 
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 void  SetPageSize( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPageSize = sVal;
				cPageSize_u = cUFlag;
		}


		/**
		 * 获取 页面大小 
		 * 
		 * @return dwPageSize value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPageSize() const {
				return dwPageSize;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cPageSize_u
		 *  
		 * 
		 */
		 void  SetPageSize_u( const uint8_t& sVal){
				cPageSize_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cPageSize_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetPageSize_u() const {
				return cPageSize_u;
		}


		/**
		 * 是否设置 排序方式 了
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 bool  IsOrderTypeSet() const{
				 return  cOrderType_u != 0;
		}


		/**
		 * 获取uflag 排序方式 了
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 const uint8_t   GetOrderTypeUFlag() const{
				 return  cOrderType_u;
		}


		/**
		 * 设置 排序方式 
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 void  SetOrderType( const uint16_t& sVal, uint8_t cUFlag=1){
				wOrderType = sVal;
				cOrderType_u = cUFlag;
		}


		/**
		 * 获取 排序方式 
		 * 
		 * @return wOrderType value 类型为:uint16_t
		 * 
		 */
		 const uint16_t&  GetOrderType() const {
				return wOrderType;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cOrderType_u
		 *  
		 * 
		 */
		 void  SetOrderType_u( const uint8_t& sVal){
				cOrderType_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cOrderType_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetOrderType_u() const {
				return cOrderType_u;
		}


		/**
		 * 是否设置Id列表，若填写则其他过滤条件无效了
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 bool  IsIdListSet() const{
				 return  cIdList_u != 0;
		}


		/**
		 * 获取uflagId列表，若填写则其他过滤条件无效了
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 const uint8_t   GetIdListUFlag() const{
				 return  cIdList_u;
		}


		/**
		 * 设置Id列表，若填写则其他过滤条件无效
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 void  SetIdList( const std::set<uint32_t> & sVal, uint8_t cUFlag=1){
				setIdList = sVal;
				cIdList_u = cUFlag;
		}


		/**
		 * 获取Id列表，若填写则其他过滤条件无效
		 * 
		 * @return setIdList value 类型为:std::set<uint32_t> 
		 * 
		 */
		 const std::set<uint32_t> &  GetIdList() const {
				return setIdList;
		}


		/**
		 * 获取Id列表，若填写则其他过滤条件无效
		 * 
		 * @return setIdList value 类型为:std::set<uint32_t> 
		 * 
		 */
		 std::set<uint32_t> &  GetIdList() {
				return setIdList;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cIdList_u
		 *  
		 * 
		 */
		 void  SetIdList_u( const uint8_t& sVal){
				cIdList_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cIdList_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetIdList_u() const {
				return cIdList_u;
		}


		/**
		 * 是否设置 HelloWorld 名称 了
		 * 
		 * @param std::string:strHelloWorldName
		 *  
		 * 
		 */
		 bool  IsHelloWorldNameSet() const{
				 return  cHelloWorldName_u != 0;
		}


		/**
		 * 获取uflag HelloWorld 名称 了
		 * 
		 * @param std::string:strHelloWorldName
		 *  
		 * 
		 */
		 const uint8_t   GetHelloWorldNameUFlag() const{
				 return  cHelloWorldName_u;
		}


		/**
		 * 设置 HelloWorld 名称 
		 * 
		 * @param std::string:strHelloWorldName
		 *  
		 * 
		 */
		 void  SetHelloWorldName( const std::string& sVal, uint8_t cUFlag=1){
				strHelloWorldName = sVal;
				cHelloWorldName_u = cUFlag;
		}


		/**
		 * 获取 HelloWorld 名称 
		 * 
		 * @return strHelloWorldName value 类型为:std::string
		 * 
		 */
		 const std::string&  GetHelloWorldName() const {
				return strHelloWorldName;
		}


		/**
		 * 获取 HelloWorld 名称 
		 * 
		 * @return strHelloWorldName value 类型为:std::string
		 * 
		 */
		 std::string&  GetHelloWorldName() {
				return strHelloWorldName;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cHelloWorldName_u
		 *  
		 * 
		 */
		 void  SetHelloWorldName_u( const uint8_t& sVal){
				cHelloWorldName_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cHelloWorldName_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetHelloWorldName_u() const {
				return cHelloWorldName_u;
		}


		/**
		 * 是否设置 添加时间，上限了
		 * 
		 * @param uint32_t:dwCreateTimeBegin
		 *  
		 * 
		 */
		 bool  IsCreateTimeBeginSet() const{
				 return  cCreateTimeBegin_u != 0;
		}


		/**
		 * 获取uflag 添加时间，上限了
		 * 
		 * @param uint32_t:dwCreateTimeBegin
		 *  
		 * 
		 */
		 const uint8_t   GetCreateTimeBeginUFlag() const{
				 return  cCreateTimeBegin_u;
		}


		/**
		 * 设置 添加时间，上限
		 * 
		 * @param uint32_t:dwCreateTimeBegin
		 *  
		 * 
		 */
		 void  SetCreateTimeBegin( const uint32_t& sVal, uint8_t cUFlag=1){
				dwCreateTimeBegin = sVal;
				cCreateTimeBegin_u = cUFlag;
		}


		/**
		 * 获取 添加时间，上限
		 * 
		 * @return dwCreateTimeBegin value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetCreateTimeBegin() const {
				return dwCreateTimeBegin;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cCreateTimeBegin_u
		 *  
		 * 
		 */
		 void  SetCreateTimeBegin_u( const uint8_t& sVal){
				cCreateTimeBegin_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cCreateTimeBegin_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetCreateTimeBegin_u() const {
				return cCreateTimeBegin_u;
		}


		/**
		 * 是否设置 添加时间，下限了
		 * 
		 * @param uint32_t:dwCreateTimeEnd
		 *  
		 * 
		 */
		 bool  IsCreateTimeEndSet() const{
				 return  cCreateTimeEnd_u != 0;
		}


		/**
		 * 获取uflag 添加时间，下限了
		 * 
		 * @param uint32_t:dwCreateTimeEnd
		 *  
		 * 
		 */
		 const uint8_t   GetCreateTimeEndUFlag() const{
				 return  cCreateTimeEnd_u;
		}


		/**
		 * 设置 添加时间，下限
		 * 
		 * @param uint32_t:dwCreateTimeEnd
		 *  
		 * 
		 */
		 void  SetCreateTimeEnd( const uint32_t& sVal, uint8_t cUFlag=1){
				dwCreateTimeEnd = sVal;
				cCreateTimeEnd_u = cUFlag;
		}


		/**
		 * 获取 添加时间，下限
		 * 
		 * @return dwCreateTimeEnd value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetCreateTimeEnd() const {
				return dwCreateTimeEnd;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cCreateTimeEnd_u
		 *  
		 * 
		 */
		 void  SetCreateTimeEnd_u( const uint8_t& sVal){
				cCreateTimeEnd_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cCreateTimeEnd_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetCreateTimeEnd_u() const {
				return cCreateTimeEnd_u;
		}


		/**
		 * 是否设置 扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 bool  IsExternSet() const{
				 return  cExtern_u != 0;
		}


		/**
		 * 获取uflag 扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 const uint8_t   GetExternUFlag() const{
				 return  cExtern_u;
		}


		/**
		 * 设置 扩展
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 void  SetExtern( const std::map<std::string,std::string> & sVal, uint8_t cUFlag=1){
				mapExtern = sVal;
				cExtern_u = cUFlag;
		}


		/**
		 * 获取 扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 const std::map<std::string,std::string> &  GetExtern() const {
				return mapExtern;
		}


		/**
		 * 获取 扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 std::map<std::string,std::string> &  GetExtern() {
				return mapExtern;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cExtern_u
		 *  
		 * 
		 */
		 void  SetExtern_u( const uint8_t& sVal){
				cExtern_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cExtern_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetExtern_u() const {
				return cExtern_u;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化 版本号    类型为uint32_t
			bsTmp & cVersion_u; // 序列化 类型为uint8_t
			bsTmp & dwPage; // 序列化 页码，从0开始  类型为uint32_t
			bsTmp & cPage_u; // 序列化 类型为uint8_t
			bsTmp & dwPageSize; // 序列化 页面大小  类型为uint32_t
			bsTmp & cPageSize_u; // 序列化 类型为uint8_t
			bsTmp & wOrderType; // 序列化 排序方式  类型为uint16_t
			bsTmp & cOrderType_u; // 序列化 类型为uint8_t
			bsTmp & setIdList; // 序列化Id列表，若填写则其他过滤条件无效 类型为Set
			bsTmp & cIdList_u; // 序列化 类型为uint8_t
			bsTmp & strHelloWorldName; // 序列化 HelloWorld 名称  类型为String
			bsTmp & cHelloWorldName_u; // 序列化 类型为uint8_t
			bsTmp & dwCreateTimeBegin; // 序列化 添加时间，上限 类型为uint32_t
			bsTmp & cCreateTimeBegin_u; // 序列化 类型为uint8_t
			bsTmp & dwCreateTimeEnd; // 序列化 添加时间，下限 类型为uint32_t
			bsTmp & cCreateTimeEnd_u; // 序列化 类型为uint8_t
			bsTmp & mapExtern; // 序列化 扩展 类型为Map
			bsTmp & cExtern_u; // 序列化 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyHelloWorldFilterDdo(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:version";
				return false;
			}

			if(!IsPageSet()){
				m_sLastErrMsg = "Miss Param:page";
				return false;
			}

			if(!IsPageSizeSet()){
				m_sLastErrMsg = "Miss Param:pageSize";
				return false;
			}

			if(!IsOrderTypeSet()){
				m_sLastErrMsg = "Miss Param:orderType";
				return false;
			}

			if(!IsIdListSet()){
				m_sLastErrMsg = "Miss Param:idList";
				return false;
			}

			if(!IsHelloWorldNameSet()){
				m_sLastErrMsg = "Miss Param:helloWorldName";
				return false;
			}

			if(!IsCreateTimeBeginSet()){
				m_sLastErrMsg = "Miss Param:createTimeBegin";
				return false;
			}

			if(!IsCreateTimeEndSet()){
				m_sLastErrMsg = "Miss Param:createTimeEnd";
				return false;
			}

			if(!IsExternSet()){
				m_sLastErrMsg = "Miss Param:extern";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[dwPage:"<<dwPage<<"] ";
			oss<<"[cPage_u:"<<(int)cPage_u<<"] ";
			oss<<"[dwPageSize:"<<dwPageSize<<"] ";
			oss<<"[cPageSize_u:"<<(int)cPageSize_u<<"] ";
			oss<<"[wOrderType:"<<(int)wOrderType<<"] ";
			oss<<"[cOrderType_u:"<<(int)cOrderType_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cIdList_u:"<<(int)cIdList_u<<"] ";
			oss<<"[strHelloWorldName:"<<strHelloWorldName<<"] ";
			oss<<"[cHelloWorldName_u:"<<(int)cHelloWorldName_u<<"] ";
			oss<<"[dwCreateTimeBegin:"<<dwCreateTimeBegin<<"] ";
			oss<<"[cCreateTimeBegin_u:"<<(int)cCreateTimeBegin_u<<"] ";
			oss<<"[dwCreateTimeEnd:"<<dwCreateTimeEnd<<"] ";
			oss<<"[cCreateTimeEnd_u:"<<(int)cCreateTimeEnd_u<<"] ";

			std::map<std::string,std::string>::const_iterator itmapExtern=mapExtern.begin();
			std::map<std::string,std::string>::const_iterator itmapExternEnd=mapExtern.end();
			for(;itmapExtern!=itmapExternEnd;itmapExtern++)
				oss<<"[mapExtern:"<<itmapExtern->second<<"] ";
			oss<<"[cExtern_u:"<<(int)cExtern_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"cVersion_u:"<<cVersion_u;
			oss<<"dwPage:"<<dwPage;
			oss<<"cPage_u:"<<cPage_u;
			oss<<"dwPageSize:"<<dwPageSize;
			oss<<"cPageSize_u:"<<cPageSize_u;
			oss<<"wOrderType:"<<wOrderType;
			oss<<"cOrderType_u:"<<cOrderType_u;
			oss<<"setIdList:"<<setIdList;
			oss<<"cIdList_u:"<<cIdList_u;
			oss<<"strHelloWorldName:"<<strHelloWorldName;
			oss<<"cHelloWorldName_u:"<<cHelloWorldName_u;
			oss<<"dwCreateTimeBegin:"<<dwCreateTimeBegin;
			oss<<"cCreateTimeBegin_u:"<<cCreateTimeBegin_u;
			oss<<"dwCreateTimeEnd:"<<dwCreateTimeEnd;
			oss<<"cCreateTimeEnd_u:"<<cCreateTimeEnd_u;
			oss<<"mapExtern:"<<mapExtern;
			oss<<"cExtern_u:"<<cExtern_u;
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "dwPage", dwPage, ident);
			g_pprint(os, "cPage_u", cPage_u, ident);
			g_pprint(os, "dwPageSize", dwPageSize, ident);
			g_pprint(os, "cPageSize_u", cPageSize_u, ident);
			g_pprint(os, "wOrderType", wOrderType, ident);
			g_pprint(os, "cOrderType_u", cOrderType_u, ident);
			g_pprint(os, "setIdList", setIdList, ident);
			g_pprint(os, "cIdList_u", cIdList_u, ident);
			g_pprint(os, "strHelloWorldName", strHelloWorldName, ident);
			g_pprint(os, "cHelloWorldName_u", cHelloWorldName_u, ident);
			g_pprint(os, "dwCreateTimeBegin", dwCreateTimeBegin, ident);
			g_pprint(os, "cCreateTimeBegin_u", cCreateTimeBegin_u, ident);
			g_pprint(os, "dwCreateTimeEnd", dwCreateTimeEnd, ident);
			g_pprint(os, "cCreateTimeEnd_u", cCreateTimeEnd_u, ident);
			g_pprint(os, "mapExtern", mapExtern, ident);
			g_pprint(os, "cExtern_u", cExtern_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}

#endif /* ERP_HELLOWORLD_DDO_CHELLOWORLDFILTERDDO_BY_AUTOGEN_V5_H */
